'Weak Dependency Graph [60.0]' ------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , top(mark(X)) -> top(proper(X)) , top(ok(X)) -> top(active(X))} Details: We have computed the following set of weak (innermost) dependency pairs: { active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z))) , active^#(__(X, nil())) -> c_1() , active^#(__(nil(), X)) -> c_2() , active^#(U11(tt())) -> c_3(U12^#(tt())) , active^#(U12(tt())) -> c_4() , active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , active^#(U11(X)) -> c_8(U11^#(active(X))) , active^#(U12(X)) -> c_9(U12^#(active(X))) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , U11^#(mark(X)) -> c_13(U11^#(X)) , U12^#(mark(X)) -> c_14(U12^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , proper^#(nil()) -> c_17() , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , proper^#(tt()) -> c_19() , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X)) , U12^#(ok(X)) -> c_24(U12^#(X)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , top^#(mark(X)) -> c_26(top^#(proper(X))) , top^#(ok(X)) -> c_27(top^#(active(X)))} The usable rules are: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} The estimated dependency graph contains the following edges: {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {active^#(U11(X)) -> c_8(U11^#(active(X)))} ==> {U11^#(ok(X)) -> c_23(U11^#(X))} {active^#(U11(X)) -> c_8(U11^#(active(X)))} ==> {U11^#(mark(X)) -> c_13(U11^#(X))} {active^#(U12(X)) -> c_9(U12^#(active(X)))} ==> {U12^#(ok(X)) -> c_24(U12^#(X))} {active^#(U12(X)) -> c_9(U12^#(active(X)))} ==> {U12^#(mark(X)) -> c_14(U12^#(X))} {active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} ==> {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} {active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} ==> {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {U11^#(mark(X)) -> c_13(U11^#(X))} ==> {U11^#(ok(X)) -> c_23(U11^#(X))} {U11^#(mark(X)) -> c_13(U11^#(X))} ==> {U11^#(mark(X)) -> c_13(U11^#(X))} {U12^#(mark(X)) -> c_14(U12^#(X))} ==> {U12^#(ok(X)) -> c_24(U12^#(X))} {U12^#(mark(X)) -> c_14(U12^#(X))} ==> {U12^#(mark(X)) -> c_14(U12^#(X))} {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} ==> {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} ==> {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} ==> {U11^#(ok(X)) -> c_23(U11^#(X))} {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} ==> {U11^#(mark(X)) -> c_13(U11^#(X))} {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} ==> {U12^#(ok(X)) -> c_24(U12^#(X))} {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} ==> {U12^#(mark(X)) -> c_14(U12^#(X))} {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} ==> {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} ==> {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} ==> {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} ==> {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} {__^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} ==> {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} {U11^#(ok(X)) -> c_23(U11^#(X))} ==> {U11^#(ok(X)) -> c_23(U11^#(X))} {U11^#(ok(X)) -> c_23(U11^#(X))} ==> {U11^#(mark(X)) -> c_13(U11^#(X))} {U12^#(ok(X)) -> c_24(U12^#(X))} ==> {U12^#(ok(X)) -> c_24(U12^#(X))} {U12^#(ok(X)) -> c_24(U12^#(X))} ==> {U12^#(mark(X)) -> c_14(U12^#(X))} {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} ==> {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} ==> {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} {top^#(mark(X)) -> c_26(top^#(proper(X)))} ==> {top^#(ok(X)) -> c_27(top^#(active(X)))} {top^#(mark(X)) -> c_26(top^#(proper(X)))} ==> {top^#(mark(X)) -> c_26(top^#(proper(X)))} {top^#(ok(X)) -> c_27(top^#(active(X)))} ==> {top^#(ok(X)) -> c_27(top^#(active(X)))} {top^#(ok(X)) -> c_27(top^#(active(X)))} ==> {top^#(mark(X)) -> c_26(top^#(proper(X)))} We consider the following path(s): 1) { active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} and weakly orienting the rules {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [3] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} and weakly orienting the rules { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules { active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [10] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [8] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [8] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} and weakly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [5] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(2) -> 2 , nil_0() -> 2 , tt_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , __^#_0(2, 2) -> 1 , c_11_0(1) -> 1 , c_12_0(1) -> 1 , c_22_0(1) -> 1} 2) { active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} and weakly orienting the rules {__^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__^#(X1, mark(X2)) -> c_12(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [3] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} and weakly orienting the rules { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules { active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [10] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [8] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [8] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} and weakly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [5] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , __^#_0(3, 3) -> 14 , __^#_0(3, 4) -> 14 , __^#_0(3, 6) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(4, 3) -> 14 , __^#_0(4, 4) -> 14 , __^#_0(4, 6) -> 14 , __^#_0(4, 10) -> 14 , __^#_0(6, 3) -> 14 , __^#_0(6, 4) -> 14 , __^#_0(6, 6) -> 14 , __^#_0(6, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 4) -> 14 , __^#_0(10, 6) -> 14 , __^#_0(10, 10) -> 14 , c_11_0(14) -> 14 , c_12_0(14) -> 14 , c_22_0(14) -> 14} 3) { top^#(mark(X)) -> c_26(top^#(proper(X))) , top^#(ok(X)) -> c_27(top^#(active(X)))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , top^#(mark(X)) -> c_26(top^#(proper(X))) , top^#(ok(X)) -> c_27(top^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [5] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [2] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [9] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [8] c_26(x1) = [1] x1 + [0] c_27(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [11] c_26(x1) = [1] x1 + [9] c_27(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [4] isNePal(x1) = [1] x1 + [4] proper(x1) = [1] x1 + [5] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [14] c_26(x1) = [1] x1 + [0] c_27(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [6] U11(x1) = [1] x1 + [4] tt() = [0] U12(x1) = [1] x1 + [4] isNePal(x1) = [1] x1 + [4] proper(x1) = [1] x1 + [10] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [1] x1 + [2] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [4] U11(x1) = [1] x1 + [8] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [8] proper(x1) = [1] x1 + [8] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [1] x1 + [6] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [8] U11(x1) = [1] x1 + [0] tt() = [1] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [8] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_26(x1) = [1] x1 + [1] c_27(x1) = [1] x1 + [1] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , top^#(mark(X)) -> c_26(top^#(proper(X)))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(U11(tt())) -> mark(U12(tt())) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , top^#(mark(X)) -> c_26(top^#(proper(X)))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(U11(tt())) -> mark(U12(tt())) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , top^#(ok(X)) -> c_27(top^#(active(X)))} Details: The problem is Match-bounded by 1. The enriched problem is compatible with the following automaton: { active_0(3) -> 46 , active_0(4) -> 46 , active_0(6) -> 46 , active_0(10) -> 46 , active_1(3) -> 51 , active_1(4) -> 51 , active_1(6) -> 51 , active_1(10) -> 51 , active_1(49) -> 53 , mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , nil_1() -> 49 , tt_0() -> 6 , tt_1() -> 49 , proper_1(3) -> 48 , proper_1(4) -> 48 , proper_1(6) -> 48 , proper_1(10) -> 48 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , ok_1(49) -> 48 , top^#_0(3) -> 44 , top^#_0(4) -> 44 , top^#_0(6) -> 44 , top^#_0(10) -> 44 , top^#_0(46) -> 45 , top^#_1(48) -> 47 , top^#_1(51) -> 50 , top^#_1(53) -> 52 , c_26_1(47) -> 44 , c_27_0(45) -> 44 , c_27_1(50) -> 44 , c_27_1(52) -> 47} 4) { active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [5] isNePal^#(x1) = [1] x1 + [3] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X))} and weakly orienting the rules { isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [5] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [4] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [8] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [4] tt() = [4] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [12] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] isNePal^#(x1) = [1] x1 + [3] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [3] nil() = [12] U11(x1) = [1] x1 + [6] tt() = [1] U12(x1) = [1] x1 + [4] isNePal(x1) = [1] x1 + [13] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [3] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [2] isNePal^#(x1) = [1] x1 + [3] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} and weakly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , isNePal^#_0(3) -> 27 , isNePal^#_0(4) -> 27 , isNePal^#_0(6) -> 27 , isNePal^#_0(10) -> 27 , c_15_0(27) -> 27 , c_25_0(27) -> 27} 5) { active^#(U12(X)) -> c_9(U12^#(active(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , U12^#(mark(X)) -> c_14(U12^#(X))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(U12(X)) -> c_9(U12^#(active(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , U12^#(mark(X)) -> c_14(U12^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [1] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U12(X)) -> c_9(U12^#(active(X)))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(X)) -> c_9(U12^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [6] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [4] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [2] isNePal(x1) = [1] x1 + [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [15] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [12] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [2] tt() = [8] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [10] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [8] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [2] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [3] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} and weakly orienting the rules { active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [3] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U12^#(ok(X)) -> c_24(U12^#(X)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U12^#(mark(X)) -> c_14(U12^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , U12^#_0(3) -> 18 , U12^#_0(4) -> 18 , U12^#_0(6) -> 18 , U12^#_0(10) -> 18 , c_14_0(18) -> 18 , c_24_0(18) -> 18} 6) { active^#(U11(X)) -> c_8(U11^#(active(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , U11^#(mark(X)) -> c_13(U11^#(X))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(U11(X)) -> c_8(U11^#(active(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , U11^#(mark(X)) -> c_13(U11^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [1] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U11(X)) -> c_8(U11^#(active(X)))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(X)) -> c_8(U11^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [3] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X))} and weakly orienting the rules { active^#(U11(X)) -> c_8(U11^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [11] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [2] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [3] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X)) , active^#(U11(X)) -> c_8(U11^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [4] tt() = [4] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [12] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} and weakly orienting the rules { active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X)) , active^#(U11(X)) -> c_8(U11^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [2] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [9] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X)) , active^#(U11(X)) -> c_8(U11^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11^#(ok(X)) -> c_23(U11^#(X)) , active^#(U11(X)) -> c_8(U11^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , U11^#(mark(X)) -> c_13(U11^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , U11^#_0(3) -> 21 , U11^#_0(4) -> 21 , U11^#_0(6) -> 21 , U11^#_0(10) -> 21 , c_13_0(21) -> 21 , c_23_0(21) -> 21} 7) {active^#(U12(X)) -> c_9(U12^#(active(X)))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(U12(X)) -> c_9(U12^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [3] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [2] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U12(X)) -> c_9(U12^#(active(X)))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(X)) -> c_9(U12^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [1] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active^#(U12(X)) -> c_9(U12^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [2] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [2] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [3] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(U12(X)) -> c_9(U12^#(active(X))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , U12^#_0(3) -> 18 , U12^#_0(4) -> 18 , U12^#_0(6) -> 18 , U12^#_0(10) -> 18} 8) {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [3] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [3] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [3] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_7(__^#(X1, active(X2))) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , __^#_0(3, 3) -> 14 , __^#_0(3, 4) -> 14 , __^#_0(3, 6) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(4, 3) -> 14 , __^#_0(4, 4) -> 14 , __^#_0(4, 6) -> 14 , __^#_0(4, 10) -> 14 , __^#_0(6, 3) -> 14 , __^#_0(6, 4) -> 14 , __^#_0(6, 6) -> 14 , __^#_0(6, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 4) -> 14 , __^#_0(10, 6) -> 14 , __^#_0(10, 10) -> 14} 9) {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [3] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [3] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [3] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active^#(__(X1, X2)) -> c_6(__^#(active(X1), X2)) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , __^#_0(3, 3) -> 14 , __^#_0(3, 4) -> 14 , __^#_0(3, 6) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(4, 3) -> 14 , __^#_0(4, 4) -> 14 , __^#_0(4, 6) -> 14 , __^#_0(4, 10) -> 14 , __^#_0(6, 3) -> 14 , __^#_0(6, 4) -> 14 , __^#_0(6, 6) -> 14 , __^#_0(6, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 4) -> 14 , __^#_0(10, 6) -> 14 , __^#_0(10, 10) -> 14} 10) {active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [3] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [2] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [1] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [7] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [4] isNePal^#(x1) = [1] x1 + [4] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active^#(isNePal(X)) -> c_10(isNePal^#(active(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , isNePal^#_0(3) -> 27 , isNePal^#_0(4) -> 27 , isNePal^#_0(6) -> 27 , isNePal^#_0(10) -> 27} 11) {active^#(U11(X)) -> c_8(U11^#(active(X)))} The usable rules for this path are the following: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [3] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(isNePal(__(I, __(P, I)))) -> mark(U11(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt())) -> mark(tt())} and weakly orienting the rules { active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt())) -> mark(tt())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [1] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [8] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} and weakly orienting the rules { active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [3] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [3] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(__(X1, X2)) -> __(active(X1), X2) , active(__(X1, X2)) -> __(X1, active(X2)) , active(U11(X)) -> U11(active(X)) , active(U12(X)) -> U12(active(X)) , active(isNePal(X)) -> isNePal(active(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z))) , active(__(X, nil())) -> mark(X) , active(__(nil(), X)) -> mark(X) , active(U11(tt())) -> mark(U12(tt())) , active(U12(tt())) -> mark(tt()) , active(isNePal(__(I, __(P, I)))) -> mark(U11(tt())) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(U11(X)) -> c_8(U11^#(active(X)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(4) -> 12 , active^#_0(6) -> 12 , active^#_0(10) -> 12 , U11^#_0(3) -> 21 , U11^#_0(4) -> 21 , U11^#_0(6) -> 21 , U11^#_0(10) -> 21} 12) { proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , U12^#(mark(X)) -> c_14(U12^#(X))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , U12^#(mark(X)) -> c_14(U12^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U12^#(ok(X)) -> c_24(U12^#(X))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U12^#(ok(X)) -> c_24(U12^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [1] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [8] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [8] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} and weakly orienting the rules { U12^#(ok(X)) -> c_24(U12^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [3] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U12^#(mark(X)) -> c_14(U12^#(X))} and weakly orienting the rules { proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U12^#(mark(X)) -> c_14(U12^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [8] nil() = [0] U11(x1) = [1] x1 + [2] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [10] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [5] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [13] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { U12^#(mark(X)) -> c_14(U12^#(X)) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [5] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , U12^#(mark(X)) -> c_14(U12^#(X)) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , U12^#(mark(X)) -> c_14(U12^#(X)) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , U12^#(ok(X)) -> c_24(U12^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , U12^#_0(3) -> 18 , U12^#_0(4) -> 18 , U12^#_0(6) -> 18 , U12^#_0(10) -> 18 , c_14_0(18) -> 18 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33 , c_24_0(18) -> 18} 13) { proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , U11^#(mark(X)) -> c_13(U11^#(X))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , U11^#(mark(X)) -> c_13(U11^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U11^#(ok(X)) -> c_23(U11^#(X))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(ok(X)) -> c_23(U11^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [1] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [8] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [8] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} and weakly orienting the rules { U11^#(ok(X)) -> c_23(U11^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [5] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U11^#(mark(X)) -> c_13(U11^#(X))} and weakly orienting the rules { proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(mark(X)) -> c_13(U11^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [8] nil() = [0] U11(x1) = [1] x1 + [2] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [8] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [4] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { U11^#(mark(X)) -> c_13(U11^#(X)) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [5] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [1] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , U11^#(mark(X)) -> c_13(U11^#(X)) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , U11^#(mark(X)) -> c_13(U11^#(X)) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , U11^#(ok(X)) -> c_23(U11^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , U11^#_0(3) -> 21 , U11^#_0(4) -> 21 , U11^#_0(6) -> 21 , U11^#_0(10) -> 21 , c_13_0(21) -> 21 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33 , c_23_0(21) -> 21} 14) { proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , isNePal^#(mark(X)) -> c_15(isNePal^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [4] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [1] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {isNePal^#(ok(X)) -> c_25(isNePal^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [1] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [8] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [8] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} and weakly orienting the rules { isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [3] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} and weakly orienting the rules { proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {isNePal^#(mark(X)) -> c_15(isNePal^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [8] nil() = [0] U11(x1) = [1] x1 + [2] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [10] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [5] proper^#(x1) = [1] x1 + [13] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [2] mark(x1) = [1] x1 + [0] nil() = [7] U11(x1) = [1] x1 + [2] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [3] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , isNePal^#(mark(X)) -> c_15(isNePal^#(X)) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , isNePal^#(ok(X)) -> c_25(isNePal^#(X)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(2) -> 2 , nil_0() -> 2 , tt_0() -> 2 , ok_0(2) -> 2 , isNePal^#_0(2) -> 1 , c_15_0(1) -> 1 , proper^#_0(2) -> 1 , c_25_0(1) -> 1} 15) { proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [1] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [1] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [2] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [1] x1 + [2] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [2] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} and weakly orienting the rules { proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [8] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [1] x1 + [7] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [4] nil() = [1] U11(x1) = [1] x1 + [1] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(2) -> 2 , nil_0() -> 2 , tt_0() -> 2 , ok_0(2) -> 2 , __^#_0(2, 2) -> 1 , c_11_0(1) -> 1 , c_12_0(1) -> 1 , proper^#_0(2) -> 1 , c_22_0(1) -> 1} 16) {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(U11(X)) -> c_18(U11^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [3] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X)) -> c_18(U11^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { proper^#(U11(X)) -> c_18(U11^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [7] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [5] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(U11(X)) -> c_18(U11^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , U11^#_0(3) -> 21 , U11^#_0(4) -> 21 , U11^#_0(6) -> 21 , U11^#_0(10) -> 21 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33} 17) {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [4] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [5] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [5] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [1] x1 + [2] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(__(X1, X2)) -> c_16(__^#(proper(X1), proper(X2))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , __^#_0(3, 3) -> 14 , __^#_0(3, 4) -> 14 , __^#_0(3, 6) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(4, 3) -> 14 , __^#_0(4, 4) -> 14 , __^#_0(4, 6) -> 14 , __^#_0(4, 10) -> 14 , __^#_0(6, 3) -> 14 , __^#_0(6, 4) -> 14 , __^#_0(6, 6) -> 14 , __^#_0(6, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 4) -> 14 , __^#_0(10, 6) -> 14 , __^#_0(10, 10) -> 14 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33} 18) {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(U12(X)) -> c_20(U12^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [3] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U12(X)) -> c_20(U12^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { proper^#(U12(X)) -> c_20(U12^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [7] U11(x1) = [1] x1 + [0] tt() = [9] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [5] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(U12(X)) -> c_20(U12^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , U12^#_0(3) -> 18 , U12^#_0(4) -> 18 , U12^#_0(6) -> 18 , U12^#_0(10) -> 18 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33} 19) {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} The usable rules for this path are the following: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(nil()) -> ok(nil()) , proper(U11(X)) -> U11(proper(X)) , proper(tt()) -> ok(tt()) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X)) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [3] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} and weakly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} and weakly orienting the rules { proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(__(X1, X2)) -> __(proper(X1), proper(X2)) , proper(U11(X)) -> U11(proper(X)) , proper(U12(X)) -> U12(proper(X)) , proper(isNePal(X)) -> isNePal(proper(X)) , __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , U11(mark(X)) -> mark(U11(X)) , U12(mark(X)) -> mark(U12(X)) , isNePal(mark(X)) -> mark(isNePal(X)) , U11(ok(X)) -> ok(U11(X)) , U12(ok(X)) -> ok(U12(X)) , isNePal(ok(X)) -> ok(isNePal(X))} Weak Rules: { proper(nil()) -> ok(nil()) , proper(tt()) -> ok(tt()) , proper^#(isNePal(X)) -> c_21(isNePal^#(proper(X))) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(4) -> 3 , mark_0(6) -> 3 , mark_0(10) -> 3 , nil_0() -> 4 , tt_0() -> 6 , ok_0(3) -> 10 , ok_0(4) -> 10 , ok_0(6) -> 10 , ok_0(10) -> 10 , isNePal^#_0(3) -> 27 , isNePal^#_0(4) -> 27 , isNePal^#_0(6) -> 27 , isNePal^#_0(10) -> 27 , proper^#_0(3) -> 33 , proper^#_0(4) -> 33 , proper^#_0(6) -> 33 , proper^#_0(10) -> 33} 20) { active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} The usable rules for this path are the following: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z))) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [1] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [1] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} and weakly orienting the rules {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [1] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [2] c_0(x1) = [1] x1 + [2] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} and weakly orienting the rules { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [1] mark(x1) = [1] x1 + [8] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [1] x1 + [4] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2))} Weak Rules: { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2))} Weak Rules: { __^#(X1, mark(X2)) -> c_12(__^#(X1, X2)) , __^#(mark(X1), X2) -> c_11(__^#(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , __^#(ok(X1), ok(X2)) -> c_22(__^#(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(10) -> 3 , ok_0(3) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(10) -> 12 , __^#_0(3, 3) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 10) -> 14 , c_11_0(14) -> 14 , c_12_0(14) -> 14 , c_22_0(14) -> 14} 21) {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} The usable rules for this path are the following: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2)) , __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [1] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [1] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} and weakly orienting the rules {active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {__(ok(X1), ok(X2)) -> ok(__(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [1] mark(x1) = [1] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [1] x1 + [0] __^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2))} Weak Rules: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { __(mark(X1), X2) -> mark(__(X1, X2)) , __(X1, mark(X2)) -> mark(__(X1, X2))} Weak Rules: { __(ok(X1), ok(X2)) -> ok(__(X1, X2)) , active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(10) -> 3 , ok_0(3) -> 10 , ok_0(10) -> 10 , active^#_0(3) -> 12 , active^#_0(10) -> 12 , __^#_0(3, 3) -> 14 , __^#_0(3, 10) -> 14 , __^#_0(10, 3) -> 14 , __^#_0(10, 10) -> 14} 22) {active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt()))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt()))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt()))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt()))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [1] x1 + [0] U11^#(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(isNePal(__(I, __(P, I)))) -> c_5(U11^#(tt()))} Details: The given problem does not contain any strict rules 23) {active^#(U11(tt())) -> c_3(U12^#(tt()))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(U11(tt())) -> c_3(U12^#(tt()))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U11(tt())) -> c_3(U12^#(tt()))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(tt())) -> c_3(U12^#(tt()))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [1] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [1] x1 + [0] U12^#(x1) = [1] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(U11(tt())) -> c_3(U12^#(tt()))} Details: The given problem does not contain any strict rules 24) {active^#(__(X, nil())) -> c_1()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(__(X, nil())) -> c_1()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(__(X, nil())) -> c_1()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(X, nil())) -> c_1()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(__(X, nil())) -> c_1()} Details: The given problem does not contain any strict rules 25) {active^#(U12(tt())) -> c_4()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(U12(tt())) -> c_4()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U12(tt())) -> c_4()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(tt())) -> c_4()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [1] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(U12(tt())) -> c_4()} Details: The given problem does not contain any strict rules 26) {active^#(__(nil(), X)) -> c_2()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(__(nil(), X)) -> c_2()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(__(nil(), X)) -> c_2()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(__(nil(), X)) -> c_2()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [1] x1 + [1] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(__(nil(), X)) -> c_2()} Details: The given problem does not contain any strict rules 27) {proper^#(nil()) -> c_17()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(nil()) -> c_17()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(nil()) -> c_17()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(nil()) -> c_17()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(nil()) -> c_17()} Details: The given problem does not contain any strict rules 28) {proper^#(tt()) -> c_19()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(tt()) -> c_19()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(tt()) -> c_19()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(tt()) -> c_19()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] __(x1, x2) = [0] x1 + [0] x2 + [0] mark(x1) = [0] x1 + [0] nil() = [0] U11(x1) = [0] x1 + [0] tt() = [0] U12(x1) = [0] x1 + [0] isNePal(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] __^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] U12^#(x1) = [0] x1 + [0] c_4() = [0] c_5(x1) = [0] x1 + [0] U11^#(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] isNePal^#(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] c_15(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(tt()) -> c_19()} Details: The given problem does not contain any strict rules